home *** CD-ROM | disk | FTP | other *** search
/ MacWorld 1999 June / Macworld (1999-06).dmg / Shareware World / Info / For Developers / MacZoop2.0.sea / MacZoop2.0 / Required Classes / ZClipboard.cpp < prev    next >
Text File  |  1998-07-06  |  10KB  |  391 lines
  1. /*************************************************************************************************
  2. *
  3. *
  4. *            MacZoop - "the framework for the rest of us"     
  5. *
  6. *
  7. *
  8. *            ZClipboard.cpp    -- the clipboard object
  9. *
  10. *
  11. *
  12. *
  13. *
  14. *            © 1997, Graham Cox
  15. *
  16. *
  17. *
  18. *
  19. *************************************************************************************************/
  20.  
  21.  
  22. #include    "MacZoop.h"
  23.  
  24.  
  25. ZClipboard*    gClipboard = NULL;
  26.  
  27.  
  28. /*----------------------------------***  PUTDATA  ***-----------------------------------*/
  29. /*    
  30. put the handle on the clipboard with the type supplied
  31. ----------------------------------------------------------------------------------------*/
  32.  
  33. void    ZClipboard::PutData( OSType dataType, Handle someData )
  34. {
  35.     FailNILParam( someData );
  36.     
  37.     long    len = GetHandleSize( someData );
  38.     char    hs = HGetState( someData );
  39.     
  40.     HLock( someData );
  41.     PutData( dataType, *someData, len );
  42.     HSetState( someData, hs );
  43. }
  44.  
  45. /*----------------------------------***  PUTDATA  ***-----------------------------------*/
  46. /*    
  47. put arbitrary data on the clipboard with the type supplied
  48. ----------------------------------------------------------------------------------------*/
  49.  
  50. void    ZClipboard::PutData( OSType dataType, Ptr dataPtr, const long dataLen )
  51. {
  52.     Clear();
  53.     AppendData( dataType, dataPtr, dataLen );
  54.     
  55.     SendMessage( clipContentsChanged, (void*) dataType );
  56. }
  57.  
  58.  
  59. /*----------------------------------***  PUTDATA  ***-----------------------------------*/
  60. /*    
  61. put the picture on the clipboard with the type 'PICT'
  62. ----------------------------------------------------------------------------------------*/
  63.  
  64. void    ZClipboard::PutData( PicHandle aPicture )
  65. {
  66.     PutData( 'PICT', (Handle) aPicture );
  67. }
  68.  
  69. /*----------------------------------***  PUTTEXT  ***-----------------------------------*/
  70. /*    
  71. put the text on the clipboard with the type 'TEXT'
  72. ----------------------------------------------------------------------------------------*/
  73.  
  74. void    ZClipboard::PutText( Handle textH )
  75. {
  76.     PutData( 'TEXT', textH );
  77. }
  78.  
  79. /*----------------------------------***  PUTTEXT  ***-----------------------------------*/
  80. /*    
  81. put the text in an arbitrary buffer on the clipboard with the type 'TEXT'
  82. ----------------------------------------------------------------------------------------*/
  83.  
  84. void    ZClipboard::PutText( Ptr charBuf, const long textLen )
  85. {
  86.     Clear();
  87.     AppendText( charBuf, textLen );
  88. }
  89.  
  90.  
  91. /*----------------------------------***  APPENDDATA  ***--------------------------------*/
  92. /*    
  93. add the data to the clipboard with the type supplied
  94. ----------------------------------------------------------------------------------------*/
  95.  
  96. void    ZClipboard::AppendData( OSType dataType, Handle someData )
  97. {
  98.     FailNILParam( someData );
  99.     
  100.     long    len = GetHandleSize( someData );
  101.     char    hs = HGetState( someData );
  102.     
  103.     HLock( someData );
  104.     AppendData( dataType, *someData, len );
  105.     HSetState( someData, hs );
  106.     
  107.     SendMessage( clipContentsAppended, (void*) dataType );
  108. }
  109.  
  110. /*----------------------------------***  APPENDDATA  ***--------------------------------*/
  111. /*    
  112. add the arbitrary data to the clipboard with the type supplied
  113. ----------------------------------------------------------------------------------------*/
  114.  
  115. void    ZClipboard::AppendData( OSType dataType, Ptr dataPtr, const long dataLen )
  116. {
  117.     FailOSErr( PutScrap( dataLen, dataType, dataPtr ));
  118. }
  119.  
  120. /*----------------------------------***  APPENDDATA  ***--------------------------------*/
  121. /*    
  122. add the picture to the clipboard with the type 'PICT'
  123. ----------------------------------------------------------------------------------------*/
  124.  
  125. void    ZClipboard::AppendData( PicHandle aPicture )
  126. {
  127.     AppendData( 'PICT', (Handle) aPicture );
  128. }
  129.  
  130. /*----------------------------------***  APPENDTEXT  ***--------------------------------*/
  131. /*    
  132. add the text to the clipboard with the type 'TEXT'
  133. ----------------------------------------------------------------------------------------*/
  134.  
  135. void    ZClipboard::AppendText( Handle textH )
  136. {
  137.     AppendData( 'TEXT', textH );
  138. }
  139.  
  140.  
  141. /*----------------------------------***  APPENDTEXT  ***--------------------------------*/
  142. /*    
  143. add the text in an arbitrary buffer to the clipboard with the type 'TEXT'
  144. ----------------------------------------------------------------------------------------*/
  145.  
  146. void    ZClipboard::AppendText( Ptr charBuf, const long textLen )
  147. {
  148.     Handle t;
  149.     
  150.     FailOSErr( PtrToHand( charBuf, &t, textLen ));
  151.     
  152.     try
  153.     {
  154.         AppendText( t );
  155.     }
  156.     catch( OSErr err )
  157.     {
  158.         DisposeHandle( t );
  159.         
  160.         throw err;
  161.     }
  162.     
  163.     DisposeHandle( t );
  164. }
  165.  
  166. /*-------------------------------------***  CLEAR  ***----------------------------------*/
  167. /*    
  168. make the clipboard empty
  169. ----------------------------------------------------------------------------------------*/
  170.  
  171. void    ZClipboard::Clear()
  172. {
  173.     FailOSErr( ZeroScrap());
  174.     
  175.     SendMessage( clipContentsCleared, NULL );
  176. }
  177.  
  178. /*------------------------------------***  GETDATA  ***---------------------------------*/
  179. /*    
  180. get the data from the clipboard with the type requested
  181. ----------------------------------------------------------------------------------------*/
  182.  
  183. Handle    ZClipboard::GetData( OSType dataType )
  184. {
  185.     Handle    h = NULL;
  186.     long    result, offset;
  187.     
  188.     if ( dataType == Wild_Card )
  189.         GetWildcardType( &dataType );
  190.     
  191.     if ( QueryType( dataType ))
  192.     {
  193.         FailNIL( h = NewHandle( 0 ));
  194.     
  195.         result = GetScrap( h, dataType, &offset);
  196.         
  197.         if (result <= 0)
  198.         {
  199.             DisposeHandle( h );
  200.             FailOSErr( noTypeErr );
  201.         }
  202.     }
  203.     
  204.     return h;
  205. }
  206.  
  207.  
  208. /*----------------------------------***  QUERYTYPE  ***---------------------------------*/
  209. /*    
  210. does the clipboard have this data type?
  211. ----------------------------------------------------------------------------------------*/
  212.  
  213. Boolean ZClipboard::QueryType( OSType dataType )
  214. {
  215.     long    result, offset;
  216.     
  217.     if ( dataType == Wild_Card )
  218.         result = GetWildcardType( &dataType );
  219.     else
  220.         result = GetScrap( NULL, dataType, &offset );
  221.     
  222.     return ( result > 0 );
  223. }
  224.  
  225. /*----------------------------------***  GETDATASIZE  ***-------------------------------*/
  226. /*    
  227. how big is the data of this type?
  228. ----------------------------------------------------------------------------------------*/
  229.  
  230. long    ZClipboard::GetDataSize( OSType dataType )
  231. {
  232.     long    result, offset;
  233.     
  234.     if ( dataType == Wild_Card )
  235.         GetWildcardType( &dataType );
  236.     
  237.     result = GetScrap( NULL, dataType, &offset );
  238.     
  239.     if ( result > 0 )
  240.         return result;
  241.     else
  242.         return -1;
  243. }
  244.  
  245. /*--------------------------------***  GETCLIPSTATUS  ***-------------------------------*/
  246. /*    
  247. what state is the clipboard in?
  248. ----------------------------------------------------------------------------------------*/
  249.  
  250. short    ZClipboard::GetClipStatus()
  251. {
  252.     PScrapStuff    ps;
  253.     
  254.     ps = InfoScrap();
  255.     
  256.     return ps->scrapCount;
  257. }
  258.  
  259.  
  260. /*-------------------------------***  GETWILDCARDTYPE  ***------------------------------*/
  261. /*    
  262. what is the type of the first item of data on the clipboard? Returns TRUE if there is
  263. one, else FALSE.
  264. ----------------------------------------------------------------------------------------*/
  265.  
  266. Boolean    ZClipboard::GetWildcardType( OSType* aType )
  267. {
  268.     PScrapStuff        ps;
  269.     
  270.     ps = InfoScrap();
  271.     
  272.     if ( ps->scrapState > 0 &&
  273.          ps->scrapSize > 0  &&
  274.          ps->scrapHandle != NULL )
  275.     {
  276.         *aType = **(OSType**) ps->scrapHandle;
  277.     
  278.         return TRUE;
  279.     }
  280.  
  281.     return FALSE;
  282. }
  283.  
  284.  
  285. /*----------------------------------***  COUNTTYPES  ***--------------------------------*/
  286. /*    
  287. how many different types of data are there on the clipboard?
  288. ----------------------------------------------------------------------------------------*/
  289.  
  290. short    ZClipboard::CountTypes()
  291. {
  292.     PScrapStuff    ps;
  293.     long        sLen, sOffset, dLen;
  294.     short        n = 0;
  295.     char        hs;
  296.     
  297.     ps = InfoScrap();
  298.     
  299.     // n.b. if scrap has been offloaded to disc, this doesn't work and returns 0.
  300.     
  301.     if ( ps->scrapState > 0 &&
  302.          ps->scrapSize > 0  &&
  303.          ps->scrapHandle != NULL )
  304.     {
  305.         // need to work through the handle determining the number of data entries
  306.         // that exist there. We'll temporarily lock it down and use a running pointer.
  307.         
  308.         hs = HGetState( ps->scrapHandle );
  309.         HLock( ps->scrapHandle );
  310.  
  311.         Ptr p = *ps->scrapHandle;
  312.         
  313.         sLen = GetHandleSize( ps->scrapHandle );
  314.         sOffset = 0;
  315.         
  316.         while( sOffset < sLen )
  317.         {
  318.             n++;                        // one more type
  319.             p += sizeof( OSType );        // skip type bytes
  320.             dLen = *(long*) p;            // read data length    
  321.             
  322.             // if dLen is odd, round up to even number of bytes
  323.             
  324.             if ( dLen & 1 )
  325.                 dLen++;
  326.             
  327.             p += sizeof( long ) + dLen;    // point to next item
  328.             sOffset += sizeof( OSType ) + sizeof( long ) + dLen;
  329.         }
  330.         
  331.         HSetState( ps->scrapHandle, hs );
  332.     }
  333.     
  334.     return n;
  335. }
  336.  
  337.  
  338. /*----------------------------------***  GETINDTYPE  ***--------------------------------*/
  339. /*
  340. return the type of clipboard data indexed from 1 to the value returned by CountTypes.    
  341. ----------------------------------------------------------------------------------------*/
  342.  
  343. OSType    ZClipboard::GetIndType( const short index )
  344. {
  345.     OSType        theType = Wild_Card;
  346.     PScrapStuff    ps;
  347.     long        dLen, sLen, sOffset;
  348.     short        k = 0;
  349.     char        hs;
  350.     
  351.     ps = InfoScrap();
  352.     
  353.     if ( ps->scrapState > 0 &&
  354.          ps->scrapSize > 0  &&
  355.          ps->scrapHandle != NULL )
  356.     {
  357.         hs = HGetState( ps->scrapHandle );
  358.         HLock( ps->scrapHandle );
  359.  
  360.         Ptr p = *ps->scrapHandle;
  361.         
  362.         sLen = GetHandleSize( ps->scrapHandle );
  363.         sOffset = 0;
  364.         
  365.         while( sOffset < sLen )
  366.         {
  367.             k++;
  368.             
  369.             if ( k == index )
  370.             {
  371.                 theType = *(OSType*) p;
  372.                 break;
  373.             }
  374.             
  375.             p += sizeof( OSType );
  376.             dLen = *(long*) p;
  377.             
  378.             if ( dLen & 1 )
  379.                 dLen++;
  380.                 
  381.             sOffset += sizeof( OSType ) + sizeof( long ) + dLen;
  382.             p += sizeof( long ) + dLen;
  383.         }
  384.         
  385.         HSetState( ps->scrapHandle, hs );
  386.     }
  387.     
  388.     return theType;
  389. }
  390.  
  391.